…erable bodies

The SDK's Request model treats a request body as optional for every method, but
the two transports mishandled two edge cases of that contract.

OkHttp transport: a body-less POST/PUT/PATCH crashed. RequestAdapter passed a
null body straight to okhttp3.Request.Builder.method, which throws
IllegalArgumentException for the methods OkHttp treats as requiring a body. A
body-less POST is a valid, publicly-constructible SDK request, so this turned a
normal request into an unchecked exception that bypassed the pipeline and diverged
from the JDK transport (which already substitutes an empty body). The adapter now
substitutes a shared zero-length body for POST/PUT/PATCH when no body is present;
other methods keep their null body. An explicit three-token check is used rather
than OkHttp's internal HttpMethod.requiresRequestBody: that symbol is internal to
OkHttp's Kotlin module, and the SDK's Method enum cannot produce the WebDAV tokens
(PROPPATCH/REPORT) that distinguish the two sets.

JDK transport: a non-replayable streaming body whose writeTo failed mid-write
surfaced the wrong exception. When toReplayable() threw, streamingPublisher fell
back to bufferToByteArray, which called writeTo a second time. The SDK's
consume-once bodies flip their consumed guard before writing, so the second
writeTo tripped that guard and threw IllegalStateException, masking the original
IOException and escaping the @throws(IOException) contract on both execute paths.
The partial bytes from the first attempt were already gone. The catch now rethrows
the original IOException wrapped in an UncheckedIOException with a clear message
instead of re-driving the consumed body.

Adds MockWebServer coverage for body-less POST/PUT/PATCH on the OkHttp transport
and a non-replayable mid-write-failure body on the JDK transport.

When toReplayable() fails mid-write while buffering a non-replayable streaming body, the JDK transport now rethrows a checked IOException wrapping the original cause, instead of an UncheckedIOException.

The body is already partially consumed and unrecoverable at that point, so the request must fail — but it is an I/O failure and belongs in execute()'s @throws(IOException) contract. Throwing it unchecked bypassed that contract and diverged from the eager (<=64 KiB) path, which already propagates a mid-write failure as an IOException. The retry pipeline gates on isReplayable(), so a non-replayable body is never re-driven regardless of exception type.